home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / plotting / pcgplots / cgmdispl.h < prev    next >
C/C++ Source or Header  |  1992-04-24  |  9KB  |  244 lines
  1. // C++ .h file for gplot, basic display classes  -*-c++-*-
  2. // copyright Phil Andrews, Pittsburgh Supercomputing Center, 1992
  3. // all rights reserved
  4. #ifndef cgmdisplay_h
  5. #define cgmdisplay_h
  6. #include <math.h>
  7. #include <stdio.h>
  8. #include "cgm.h"
  9. ////
  10. // forward declarations
  11. ////
  12. #ifndef _XLIB_H_
  13. class XPoint;
  14. #endif
  15. // handy angle class, note completely defined by sin and cos, thus no
  16. // concept of "less than", no cuts or Riemann sheets. Inline everything.
  17. ////
  18. class angle {
  19. public:
  20.   // constructor
  21.   angle(double y, double x)
  22.     {r = sqrt(x*x + y*y); myTan = (x) ? y/x : (y<0) ? tanMax : -tanMax;
  23.      mySin = (r) ? y/r : 0; myCos = (r) ? x/r : 0;}
  24.  
  25.   double tan() const {return myTan;}
  26.   double sin() const {return mySin;}
  27.   double cos() const {return myCos;}
  28.   ////
  29.   // in this range ? (i.e., going from phi1 to phi2 covers *this)
  30.   int within(angle phi1, angle phi2)
  31.     {return (((*this - phi1).sin() >= 0) && ((phi2 - *this).sin() >= 0));}
  32.   ////
  33.   // now some overloaded operators
  34.   // minus another angle
  35.   angle operator-(angle phi) const
  36.     {return angle(sin() * phi.cos() - cos() * phi.sin(),
  37.             cos() * phi.cos() + sin() * phi.sin());}
  38.   // plus another angle
  39.   angle operator+(angle phi) const
  40.     {return angle(sin() * phi.cos() + cos() * phi.sin(),
  41.            cos() * phi.cos() - sin() * phi.sin());}
  42.   ////
  43.   // decrement operator
  44.   angle operator-=(angle phi)
  45.     {double y = sin() * phi.cos() - cos() * phi.sin();
  46.      double x = cos() * phi.cos() + sin() * phi.sin();
  47.      mySin = y; myCos = x; myTan = (x) ? y/x : (y<0) ? -tanMax : tanMax;
  48.      return *this;}
  49.   ////
  50.   // increment operator
  51.   angle operator+=(angle phi)
  52.   {double y = sin() * phi.cos() + cos() * phi.sin();
  53.    double x =  cos() * phi.cos() - sin() * phi.sin();
  54.    mySin = y; myCos = x; myTan = (x) ? y/x : (y<0) ? -tanMax : tanMax;
  55.    return *this;}
  56.   ////
  57.   double size() {return r;} // careful with this !
  58. protected:
  59.   double myTan, mySin, myCos, r;
  60.   static const double tanMax;
  61. };    
  62. ////
  63. // base display class
  64. ////
  65. class baseDisplay { 
  66. public:
  67.   baseDisplay(); // default constructor
  68.   virtual ~baseDisplay() {if (myPxlExtent) delete myPxlExtent;}
  69.   ////
  70.   // delimiters
  71.   virtual void newMF(){} // default
  72.   void newPic(); // not virtual, must be calle
  73.   virtual void startPic() {} // default function
  74.   void newPicBody(float, float, float=0, float=0); // not virtual, must call
  75.   virtual void clearScreen(const char* = NULL){} // default function
  76.   virtual void endPic(){} // default function
  77.   virtual void endMF(){} // default function
  78.   ////
  79.   // control elements, all default
  80.   virtual void transparency(int inTrans) {myTrans = inTrans;}
  81.   virtual void clipRect(const vdcPts *inPts) {myClipRect = inPts;}
  82.   virtual void clip(int inClip) {myClip = inClip;}
  83.   virtual void backColr(const genColr&) {}
  84.   ////
  85.   // graphical primitives, polyline required rest default
  86.   virtual int polyline(const vdcPts*) = 0; // required in all descendants
  87.   virtual int disPolyline(const vdcPts*); // default function
  88.   virtual int polymarker(const vdcPts*); // default function
  89.   virtual int text(const genText*); // default function
  90.   virtual int polygon(const vdcPts*); // default function
  91.   virtual int polygonSet(const vdcPts*, const int*); // default function
  92.   virtual int cells(const cellArray*); // default function
  93.   virtual int rectangle(const vdcPts*); // default function
  94.   virtual int circle(const vdcPts*, const vdc*, int=0); // default function
  95.   virtual int arc3Pt(const vdcPts*, int); // default function
  96.   virtual int arcCtr(const vdcPts*, vdc*, int); // default function
  97.   virtual int ellipse(const vdcPts*); // default function
  98.   virtual int ellipArc(const vdcPts*, int); // default function
  99.   ////
  100.   // attributes, all default functions
  101.   virtual void lineIndex(int inIndex) {myLineIndex = inIndex;}
  102.   virtual void lineType(int inType) {myLineType = inType;}
  103.   virtual void lineWidth(const vdcR *inWidth) {myLineWidth = inWidth;}
  104.   virtual void lineColr(const genColr &inColr) {}
  105.   virtual void markerIndex(int inIndex) {myMarkerIndex = inIndex;}
  106.   virtual void markerType(int inType) {myMarkerType = inType;}
  107.   virtual void markerSize(const vdcR *inSize) {myMarkerSize = inSize;}
  108.   virtual void markerColr(const genColr &inColr) {}
  109.   virtual void textIndex(int inIndex) {myTextIndex = inIndex;}
  110.   virtual void fontIndex(int inIndex) {myFontIndex = inIndex;}
  111.   virtual void textPrec(int inType) {myTextPrec = inType;}
  112.   virtual void charSpace(float inFloat) {myCharSpace = inFloat;}
  113.   virtual void charExpan(float inFloat) {myCharExpan = inFloat;}
  114.   virtual void textColr(const genColr&) {}
  115.   virtual void charHeight(const vdc *inHeight) {myCharHeight = inHeight;}
  116.   virtual void charOri(const vdcPts *inOri) {myCharOri = inOri;}
  117.   virtual void textPath(int inPath) {myTextPath = inPath;}
  118.   virtual void textAlign(const alignment *inAlign) {myTextAlign = inAlign;}
  119.   virtual void charSetIndex(int inIndex) {myCharSetIndex = inIndex;}
  120.   virtual void altCharSetIndex(int inIndex) {myAltCharSetIndex = inIndex;}
  121.   virtual void fillIndex(int inIndex) {myFillIndex = inIndex;}
  122.   virtual void intStyle(int inStyle) {myIntStyle = inStyle;}
  123.   virtual void fillColr(const genColr&){}
  124.   virtual void hatchIndex(int inIndex) {myHatchIndex = inIndex;}
  125.   virtual void patIndex(int inIndex) {myPatIndex = inIndex;}
  126.   virtual void edgeIndex(int inIndex) {myEdgeIndex = inIndex;}
  127.   virtual void edgeType(int inType) {myEdgeType = inType;}
  128.   virtual void edgeWidth(const vdcR *inWidth) {myEdgeWidth = inWidth;}
  129.   virtual void edgeVis(int inVis) {myEdgeVis = inVis;}
  130.   virtual void edgeColr(const genColr &inColr) {}
  131.   virtual void fillRefPt(const vdcPts *inPts) {myFillRefPt = inPts;}
  132.   virtual void colrs(const colrTable*); // a colour table 
  133.   ////
  134.   // check on requirements of display
  135.   virtual int invert() {return 0;} // do we need inversion of vdc pts ?
  136.   virtual int picDefaults() {return 1;} // do we need defaults for each page
  137.   virtual int fileDefaults() {return 0;} // do we need defaults for each file
  138. protected:
  139.   // utility functions
  140.   int getSize(const vdc *inVDC) // size in x pixels
  141.     {return (inVDC) ? (inVDC->type()) ? (int) (inVDC->f() * useScale) :
  142.      (int) (inVDC->i() * useScale) : 0;}
  143.   int getPts(const vdcPts*, int*&, int=0); // get right format of points
  144.   int getPts(const vdcPts*, float*&, int=0); // get right format of points
  145.   int getPts(const vdcPts*, short*&, int=0); // get right format of points
  146.   int getPts(const vdcPts*, XPoint*&, int=0); // get right format of points
  147.   vdcPts *getArc(const vdcPts*, const vdc*, const angle*, const angle*,
  148.          int=-1, const vdc* = NULL, const angle* = NULL); 
  149.   float greyColr(float r, float g, float b) // grey equivalent
  150.     {return 1.0 - (0.3 * r + 0.59 * g + 0.11 * b);}
  151.   float greyColr(float *inF) // convenience function
  152.     {return greyColr(inF[0], inF[1], inF[2]);}
  153.   ////
  154.   virtual vdcPts *pxlExtent() {return myPxlExtent;} // pixel extent
  155.   virtual float xPxlSize() = 0; // x pixel size in mm (required)
  156.   virtual float yPxlSize() = 0; // y pixel size in mm (required)
  157.   // state variables
  158.   //
  159.   // variables for scaling
  160.   float vdcWidth, vdcHeight, devWidth, devHeight, xScale, yScale, useScale;
  161.   float useOff[4];
  162.   // control elements
  163.   int myTrans;
  164.   const vdcPts *myClipRect;
  165.   int myClip;
  166.   //
  167.   // attributes
  168.   int myLineIndex;
  169.   int myLineType;
  170.   const vdcR *myLineWidth;
  171.   int myMarkerIndex;
  172.   int myMarkerType;
  173.   const vdcR *myMarkerSize;
  174.   int myTextIndex;
  175.   int myFontIndex;
  176.   int myTextPrec;
  177.   float myCharExpan;
  178.   float myCharSpace;
  179.   const vdc *myCharHeight;
  180.   const vdcPts *myCharOri;
  181.   int myTextPath;
  182.   const alignment *myTextAlign;
  183.   int myCharSetIndex;
  184.   int myAltCharSetIndex;
  185.   int myFillIndex;
  186.   int myIntStyle;
  187.   int myHatchIndex;
  188.   int myPatIndex;
  189.   int myEdgeIndex;
  190.   int myEdgeType;
  191.   const vdcR *myEdgeWidth;
  192.   int myEdgeVis;
  193.   const vdcPts *myFillRefPt;
  194.   // externally imposed values
  195.   int myXSize, myYSize;
  196.   vdcPts *myPxlExtent;
  197. };
  198. ////
  199. // class to hold a character in an Hershey font form
  200. ////
  201. class hersheyChar {
  202. public:
  203.   hersheyChar(const genText*, int, int=0);
  204.   ~hersheyChar();
  205.   hersheyChar *next;
  206.   int display(baseDisplay*);
  207.   void shift(float&, float&);
  208.   float shift1() {return myShift1;}
  209.   float shift2() {return myShift2;}
  210.   float shiftY1() {return myShiftY1;}
  211.   float shiftY2() {return myShiftY2;}
  212.   float width() {return shift1() + shift2();}
  213.   float height() {return myHeight;}
  214.   float depth() {return myDepth;}
  215.   void scale(float);
  216. protected:
  217.   vdcPts *contents;
  218.   static const int maxOffset;
  219.   void addPts(vdcPts*);
  220.   float myShift1, myShift2, myHeight, myDepth, myShiftY1, myShiftY2;
  221. };
  222. ////
  223. // class to hold a string in an Hershey font form
  224. ////
  225. class hersheyString {
  226. public:
  227.   hersheyString(const genText*);
  228.   ~hersheyString();
  229.   int display(baseDisplay*);
  230.   void right(const genText*, float&, float&);
  231.   void left(const genText*, float&, float&);
  232.   void up(const genText*, float&, float&);
  233.   void down(const genText*, float&, float&);
  234.   float width(); // the width of the string
  235.   void scale(float); // scale the string
  236.   float height() {return myHeight;}
  237.   float depth() {return myDepth;}
  238. protected:
  239.   hersheyChar *contents;
  240.   void addChar(hersheyChar*);
  241.   float myHeight, myDepth;
  242. };
  243. #endif // cgmdisplay_h
  244.